home *** CD-ROM | disk | FTP | other *** search
/ Night Owl 7 / Night Owl Shareware (NOPV7)(Night Owl Publisher Inc.)(1992).bin / 038a / bash1_12.arj / BASH1-12.TAR / bash-1.12 / builtins / read.def < prev    next >
Text File  |  1992-01-20  |  5KB  |  207 lines
  1. This file is read.def, from which is created read.c.
  2. It implements the builtin "read" in Bash.
  3.  
  4. Copyright (C) 1987, 1989, 1991 Free Software Foundation, Inc.
  5.  
  6. This file is part of GNU Bash, the Bourne Again SHell.
  7.  
  8. Bash is free software; you can redistribute it and/or modify it under
  9. the terms of the GNU General Public License as published by the Free
  10. Software Foundation; either version 1, or (at your option) any later
  11. version.
  12.  
  13. Bash is distributed in the hope that it will be useful, but WITHOUT ANY
  14. WARRANTY; without even the implied warranty of MERCHANTABILITY or
  15. FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  16. for more details.
  17.  
  18. You should have received a copy of the GNU General Public License along
  19. with Bash; see the file COPYING.  If not, write to the Free Software
  20. Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  21.  
  22. $PRODUCES read.c
  23.  
  24. $BUILTIN read
  25. $FUNCTION read_builtin
  26. $SHORT_DOC read [-r] [name ...]
  27. One line is read from the standard input, and the first word is
  28. assigned to the first NAME, the second word to the second NAME, etc.
  29. with leftover words assigned to the last NAME.  Only the characters
  30. found in $IFS are recognized as word delimiters.  The return code is
  31. zero, unless end-of-file is encountered.  If the -r option is given,
  32. this signifies `raw' input, and backslash processing is disabled.
  33. $END
  34.  
  35. #include <stdio.h>
  36. #include "../shell.h"
  37.  
  38. static int stream_close ();
  39.  
  40. /* Read the value of the shell variables whose names follow.
  41.    The reading is done from the current input stream, whatever
  42.    that may be.  Successive words of the input line are assigned
  43.    to the variables mentioned in LIST.  The last variable in LIST
  44.    gets the remainder of the words on the line.  If no variables
  45.    are mentioned in LIST, then the default variable is $REPLY.
  46.  
  47.    S. R. Bourne's shell complains if you don't name a variable
  48.    to receive the stuff that is read.  GNU's shell doesn't.  This
  49.    allows you to let the user type random things. */
  50. read_builtin (list)
  51.      WORD_LIST *list;
  52. {
  53.   extern int interrupt_immediately, free ();
  54.   extern SHELL_VAR *bind_variable ();
  55.   extern char *string_list_dollar_star ();
  56.   register char *varname;
  57.   int size, c, i, fildes, raw_mode, pass_next;
  58.   char *input_string, *ifs_chars;
  59.   WORD_LIST *words, *rwords, *list_string ();
  60.   FILE *input_stream;
  61.  
  62.   i = 0;        /* Index into the string that we are reading. */
  63.   raw_mode = 0;        /* Not reading raw input be default. */
  64.  
  65.   ifs_chars = get_string_value ("IFS");
  66.   input_string = (char *)xmalloc (size = 128);
  67.  
  68.   /* We need unbuffered input from stdin.  So we make a new stream with
  69.      the same file descriptor as stdin, then unbuffer it. */
  70.   fildes = dup (fileno (stdin));
  71.  
  72.   if (fildes == -1)
  73.     return (EXECUTION_FAILURE);
  74.  
  75.   input_stream = fdopen (fildes, "r");
  76.  
  77.   if (!input_stream)
  78.     {
  79.       close (fildes);
  80.       return (EXECUTION_FAILURE);
  81.     }
  82.  
  83.   setbuf (input_stream, (char *)NULL);
  84.  
  85.   {
  86.     begin_unwind_frame ("read_builtin");
  87.     add_unwind_protect (free, input_string);
  88.     add_unwind_protect (stream_close, input_stream);
  89.     interrupt_immediately++;
  90.   }
  91.  
  92.   while (list)
  93.     {
  94.       if (strcmp (list->word->word, "-r") == 0)
  95.     {
  96.       raw_mode = 1;
  97.       list = list->next;
  98.     }
  99.       else if (strcmp (list->word->word, "--") == 0)
  100.     {
  101.       list = list->next;
  102.       break;
  103.     }
  104.       else if (*list->word->word == '-')
  105.     {
  106.       bad_option (list->word->word);
  107.       return (EXECUTION_FAILURE);
  108.     }
  109.       else
  110.     break;
  111.     }
  112.  
  113.   pass_next = 0;    /* Non-zero signifies last char was backslash. */
  114.  
  115.   while ((c = getc (input_stream)) != EOF)
  116.     {
  117.       if (i + 2 >= size)
  118.     input_string = (char *)xrealloc (input_string, size += 128);
  119.  
  120.       /* If the next character is to be accepted verbatim, a backslash
  121.      newline pair still disappears from the input. */
  122.       if (pass_next)
  123.     {
  124.       if (c != '\n')
  125.         input_string[i++] = c;
  126.  
  127.       pass_next = 0;
  128.       continue;
  129.     }
  130.  
  131.       if (c == '\\' && !raw_mode)
  132.     {
  133.       pass_next++;
  134.       continue;
  135.     }
  136.  
  137.       if (c == '\n')
  138.     break;
  139.  
  140.       input_string[i++] = c;
  141.     }
  142.   input_string[i] = '\0';
  143.  
  144.   interrupt_immediately--;
  145.   discard_unwind_frame ("read_builtin");
  146.  
  147.   fclose (input_stream);
  148.  
  149.   if (c == EOF)
  150.     return (EXECUTION_FAILURE);
  151.  
  152.   if (!list)
  153.     {
  154.       SHELL_VAR *var;
  155.  
  156.       var = bind_variable ("REPLY", input_string);
  157.       var->attributes &= ~att_invisible;
  158.       free (input_string);
  159.     }
  160.   else
  161.     {
  162.       words = list_string (input_string, ifs_chars, 0);
  163.       rwords = words;
  164.  
  165.       free (input_string);
  166.  
  167.       while (list)
  168.     {
  169.       SHELL_VAR *var;
  170.  
  171.       varname = list->word->word;
  172.  
  173.       if (!list->next)
  174.         {
  175.           /* Call string_list_dollar_star because P1003.2.9 specifies
  176.          that the intervening separators are preserved in the
  177.          result of a read that specifies fewer variables than words
  178.          read. */
  179.           char *t = words ? string_list_dollar_star (words) : "";
  180.           var = bind_variable (varname, t);
  181.         }
  182.       else
  183.         var = bind_variable (varname, words ? words->word->word : "");
  184.  
  185.       stupidly_hack_special_variables (varname);
  186.       var->attributes &= ~att_invisible;
  187.  
  188.       list = list->next;
  189.       if (words)
  190.         words = words->next;
  191.     }
  192.       if (rwords)
  193.     dispose_words (rwords);
  194.     }
  195.  
  196.   return (EXECUTION_SUCCESS);
  197. }
  198.  
  199. /* This way I don't have to know whether fclose () is a
  200.    function or a macro. */
  201. static int
  202. stream_close (file)
  203.      FILE *file;
  204. {
  205.   return (fclose (file));
  206. }
  207.